Iterative autocorrelation function calculation for streamed data using components

ABSTRACT

The present invention extends to methods, systems, and computing system program products for iteratively calculating autocorrelation function for streamed data in real time by iteratively calculating one or more components of autocorrelation function. Embodiments of the invention include iteratively calculating one or more components of autocorrelation function at a specified range of lags in an adjusted computation window based on the one or more components of the autocorrelation function at the specified range of lags calculated for a previous computation window and then calculating the autocorrelation function at the specified range of lags using the iteratively calculated components. Iteratively calculating autocorrelation function avoids visiting all data elements in the adjusted computation window and performing redundant computations thereby increasing calculation efficiency, saving computing resources and reducing computing system&#39;s power consumption.

CROSS-REFERENCE TO RELATED APPLICATIONS

This application claims the benefit of provisional patent application Ser. No. 62/089,230, filed 2014 Dec. 9 by the present inventor.

BACKGROUND AND RELEVANT ART

Internet, mobile communications, navigation, online gaming, sensing technologies and large scale computing infrastructures are producing large amounts of data sets every day. Big Data is data that is beyond the processing capacity of conventional database systems and analyzing capacity of traditional analyzing methods due to its large volume and fast moving and growing speed. More companies now rely on Big Data to make real-time decisions to solve various problems. Current methods involve utilizing a lot of computational resources, which are very costly, yet still may not satisfy the needs of real-time decision making based on the newest information, especially in the financial industry. How to efficiently, promptly and cost-effectively process and analyze Big Data presents a difficult challenge to data analysts and computer scientists.

Streamed data is data that is constantly being received by a receiver while being delivered by a provider. Streamed data may be real-time data gathered from sensors and continuously transferred to computing devices or electronic devices. Often this includes receiving similarly formatted data elements in succession separated by some time interval. Big Data sets are accumulated over time and they may be considered as a data stream with irregular time intervals. Streamed data may also be data continuously read from storage devices, e.g., storage devices on multi-computing devices which store a Big Data set.

Stream processing has become a focused research area recently due to the following reasons. One reason is that the input data are coming too fast to store entirely for batch processing, so some analysis have to be performed when the data streams in. The second reason is that immediate responses to any changes of the data are required in some application domains, e.g., mobile related applications, online gaming, navigation, real-time stock analysis and automated trading, etc. The third reason is that some applications or electronic devices require streaming processing due to their nature, e.g., audio, video and digital TV, etc.

Processing streamed data may include performing calculations on multiple data elements. Thus, to process streamed data, a system comprising one or more computing devices typically includes a buffer on one or more storage media for storing some number of streamed data elements received by the system. Processing the streamed data elements may include accessing data elements stored in the buffer.

When performing an autocorrelation function calculation on streamed data elements, buffer requirements may be quite large. For example, when calculating an autocorrelation function a (potentially large) number of data elements may need to be accessed.

Further, some statistical function calculations are recalculated as new streamed data elements are accessed or received. Thus, the (potentially large) number of data elements may be repeatedly accessed. For example, it may be that an autocorrelation function is calculated for a computation window that includes the last n data elements in a data stream. As such, every time a new data element is accessed or received, the new element is added to the computation window and the current n^(th) data element is moved out of the computation window. The n data elements in the computation window are then accessed to recalculate the autocorrelation function.

As such, each data element remains in the computation window for n autocorrelation function calculations before it is aged out of the computation window. Accordingly, each data element is read from the buffer n times. When performing an autocorrelation function on n data elements all the n data elements in the computation window will be visited and used at least once at a given lag. Performing autocorrelation calculations on streamed data elements in this way is time consuming and inefficient.

Depending on necessity, the computation window size n may be extremely large, so the data elements in a computation window may be distributed over a cloud comprising hundreds of thousands of computing devices. Re-performing an autocorrelation function calculation in traditional ways on streamed data results in slow response and significant waste of computing resources.

BRIEF SUMMARY

The present disclosure describes methods, systems, and computing system program products for iteratively calculating autocorrelation function for streamed data. A computing system comprising one or more computing devices includes an input buffer on one or more storage media for storing streamed data elements. A computation window size n (n>1) indicates a specified number of data elements for filling a computation window for the input buffer. The computation window, a subset of all data elements received from a data stream, contains the data elements involved in an autocorrelation calculation. A lag upper limit maxl (1≤maxl<n) indicates a range of lags used for the autocorrelation function calculation. Iteratively calculating an autocorrelation function for an adjusted computation window includes iteratively calculating one or more (a total of no more than p*maxl (p≥1)) components of an autocorrelation function for an adjusted computation window based on one or more components of an autocorrelation function for a previous computation window and then calculating the autocorrelation function using one or more iteratively calculated components. Iteratively calculating autocorrelation function avoids visiting all data elements in the adjusted computation window and performing redundant computations thereby increasing calculation efficiency, saving computing resources and reducing computing system's power consumption. The buffer may reside in memory or other non-transitory computer-readable media, such as a hard disk or other media, and may include multiple distributed files on multiple distributed computing devices, such as may be connected end-to-end to form a “circular buffer”.

The computing system initialize a lag range, a computation window size and one or more components of an autocorrelation function at a specified range of lags for a computation window.

The computing system accesses or receives a new streamed data element subsequent to accessing or receiving the one or more additional Big Data or streamed data elements. The computing system stores the new Big Data or streamed data element in the input buffer. The computing system adjusts the computation window by removing the earlier Big Data or streamed data element from the computation window and adding the new Big Data or streamed data element to the computation window.

The computing system directly iteratively calculates one or more v (1≤v≤p) components of an autocorrelation at different lags less than the lag upper limit maxl respectively for the adjusted computation window and stores the calculated v components (e.g., into an array in memory or a file on disks). The computing system directly iteratively calculates v components of an autocorrelation at different lags for a given computation window through a loop: setting an initial value for a lag, iteratively calculating v components of the autocorrelation for the lag, storing the calculated v components, adjusting the lag with a new value within the lag upper limit maxl, calculating v components for the lag, storing the calculated v components, adjusting the lag again, calculating v components for the lag again, storing the calculated v components again, . . . , repeating this process until v components for all different lag values within the lag upper limit maxl have been calculated and stored. Directly iteratively calculating v (1≤v≤p) components at a given lag includes: accessing the data element removed from the computation window and the new data element added to the computation window from the input buffer and accessing the v components at the given lag calculated for the previous computation window; mathematically removing any contribution of the data element removed from the computation window from each of the v components at the given lag; mathematically adding a contribution of the new data element to each of the v components at the given lag.

The computing system indirectly iteratively calculates w=p−v components of an autocorrelation function at different lags within a specified range for the adjusted computation window as needed. The computing system indirectly iteratively calculates w components of an autocorrelation function at different lags for a given computation window through a loop: setting an initial value for a lag, iteratively calculating w components of the autocorrelation for the lag, adjusting the lag with a new value within the lag upper limit maxl, calculating w components for the lag, adjusting the lag again, calculating w components for the lag again, . . . , repeating this process until w components for all different lag values within the lag upper limit maxl have been calculated. Indirectly iteratively calculating w components at a given lag includes indirectly iteratively calculating each of the w components at a given lag one by one. Indirectly iteratively calculating a component at a given lag includes: accessing one or more components at the given lag and calculating the component at the given lag by using one or more components at the given lag other than the component itself. The one or more components at the given lag may have been initialized, directly iteratively calculated or indirectly iteratively calculated.

The computing system initializes a lag, and generates an autocorrelation at the given lag for a given computation window as needed by using one or more iteratively calculated components of an autocorrelation at the given lag for the given computation window. The computing system adjusts the lag to a new value within a specified range (from 1 to maxl), then generates an autocorrelation at the given lag for a given computation window as needed by using one or more iteratively calculated components of an autocorrelation at the given lag for the given computation window. The computing system repeats this process until autocorrelation function at all lags within a specified range having been generated.

The computing system keeps accessing or receiving a new data element, storing the data element into a data buffer, adjusting the computation window, directly iteratively calculating v (1≤v≤p) components at all lags within a specified range and storing the v components, indirectly iteratively calculating w=p−v components at all lags within a specified range as needed and generating an autocorrelation function at all lags within a specified range as needed, and the computing system may repeat this process for as many times as needed.

This summary is provided to introduce a selection of concepts in a simplified form that are further described below in the Detailed Description. This summary is not intended to identify key features or essential features of the claimed subject matter, nor is it intended to be used as an aid in determining the scope of the claimed subject matter.

Additional features and advantages of the invention will be set forth in the description which follows, and in part will be obvious from the description, or may be learned by the practice of the invention. The features and advantages of the invention may be realized and obtained by means of the instruments and combinations particularly pointed out in the appended claims. These and other features of the present invention will become more fully apparent from the following description and appended claims, or may be learned by the practice of the invention as set forth hereinafter.

BRIEF DESCRIPTION OF THE DRAWINGS

In order to describe the manner in which the above-recited and other advantages and features of the invention may be obtained, a more particular description of the invention briefly described above will be rendered by reference to specific embodiments thereof which are illustrated in the appended drawings. Understanding that these drawings depict only typical embodiments of the invention and are not therefore to be considered to be limiting of its scope, the invention will be described and explained with additional specificity and detail through the use of the accompanying drawings in which:

FIG. 1 illustrates a high-level overview of an example computing system that facilitates iteratively calculating autocorrelation function for streamed data.

FIG. 1A illustrates an example computing system architecture that facilitates iteratively calculating autocorrelation function for streamed data with all components being directly iteratively calculated.

FIG. 1B illustrates an example computing system architecture that facilitates iteratively calculating autocorrelation function for streamed data with some components being directly iteratively calculated and some components being indirectly iteratively calculated.

FIG. 2 illustrates a flow chart of an example method for iteratively calculating an autocorrelation for streamed data.

FIG. 3A illustrates data that is removed from and data is added to a computation window 300A for iteratively calculating an autocorrelation when the computation window 300A is moving to the right side.

FIG. 3B illustrates data that is accessed from a computation window 300A for iteratively calculating autocorrelations at all lags within a specified range (from 1 to maxl) when the computation window 300A is moving to the right side.

FIG. 3C illustrates data that is removed from and data is added to a computation window 300B for iteratively calculating an autocorrelation when the computation window 300B is moving to the left side.

FIG. 3D illustrates data that is accessed from a computation window 300B for iteratively calculating autocorrelations at all lags within a specified range (from 1 to maxl) when the computation window 300B is moving to the left side.

FIG. 4A illustrates the definition of an autocorrelation and traditional equations for calculating an autocorrelation.

FIG. 4B illustrates some example components of an autocorrelation and basic iterative component calculation equations.

FIG. 4C illustrates the equations of the first example iterative autocorrelation calculation algorithm (iterative algorithm 1).

FIG. 4D illustrates the equations of the second example iterative autocorrelation calculation algorithm (iterative algorithm 2).

FIG. 4E illustrates the equations of the third example iterative autocorrelation calculation algorithm (iterative algorithm 3).

FIG. 5A illustrates an example of calculating autocorrelation using traditional algorithms as shown in FIG. 4A.

FIG. 5B illustrates an example of calculating autocorrelation using iterative algorithm 1 as shown in FIG. 4C.

FIG. 5C illustrates an example of calculating autocorrelation using iterative algorithm 2 as shown in FIG. 4D.

FIG. 5D illustrates an example of calculating autocorrelation using iterative algorithm 3 as shown in FIG. 4E.

FIG. 6 illustrates computational loads for traditional algorithms and iterative algorithms with a computation window of size 4.

FIG. 7 illustrates computational loads for traditional algorithms and iterative algorithms with a computation window of size 1,000,000.

DETAILED DESCRIPTION

The present disclosure describes methods, systems, and computing system program products for iteratively calculating an autocorrelation function for Big Data or streamed data by iteratively calculating one or more (a total of no more than p*maxl (p≥1,1≤maxl<n)) components of an autocorrelation function and then calculating the autocorrelation function using one or more iteratively calculated components. p is the number of components of an autocorrelation at a given lag and maxl is a specified parameter which specifies a lag upper limit. Iteratively calculating autocorrelation avoids visiting all data elements in the adjusted computation window and performing redundant computations thereby increasing calculation efficiency, saving computing resources and reducing computing system's power consumption. A computing device includes an input buffer for storing Big Data or streamed data elements. A computing system comprising one or more computing devices includes a storage space for storing p*maxl components. A computation window size n indicates a specified number of Big Data or streamed data elements for filling a computation window of the input buffer. The buffer may reside in memory or other non-transitory computer-readable media, such as a hard disk or other media, and may include multiple distributed files on multiple distributed computing devices, such as may be connected end-to-end to form a “circular buffer”.

An autocorrelation is a measure of the correlation of a particular time series with the same time series delayed by l lags. It is also called “lagged correlation” or “serial correlation”. It is obtained by dividing the covariance between two observations, separated by l lags, of a time series by the standard deviation. If the autocorrelation is calculated for all values of l we obtain the autocorrelation function. For a time series that does not change over time, the autocorrelation function decreases exponentially to 0. The value of an autocorrelation is between −1 and +1. A value of 1 indicates there is a perfect positive linear relationship between the time series' past and future values. A value of −1 indicates there is an exact negative linear relationship between the time series' past and future values.

A computation window is a moving window on a Big Data set or data stream which contains the data elements involved in an autocorrelation function calculation. The computation window may move to either right or left direction. For example, when processing streamed data in real-time, the computation window moves to the right. In this case, a data element is always added to the right side of the computation window and a data element is always removed from the left side of the computation window. When recalculating an autocorrelation function on previously streamed data, the computation window may move to the left side. In this case, a data element is added to the left side of the computation window and a data element is removed from the right side of the computation window. We want to iteratively calculate the autocorrelation function within the computation window whenever the computation window moves to either right or left by one data element.

A component of an autocorrelation is a quantity or expression appearing in the autocorrelation's definition equation or any transforms of the equation. An autocorrelation is the largest component of an autocorrelation itself. An autocorrelation at a given lag may be calculated using one or more (p (p≥1)) components of the autocorrelation at the given lag. Some example components of an autocorrelation may be found in FIG. 4B.

A component may be either directly iteratively calculated or indirectly iteratively calculated. The difference between them is that when directly iteratively calculating a component the component is calculated by using the component's value in previous iteration but when indirectly iteratively calculating a component the component is calculated by using components other than the component itself.

For a given component, it might be directly iteratively calculated in one algorithm but indirectly iteratively calculated in another algorithm.

For a given algorithm, assume the total number of different components is p (p≥1), the number of directly iteratively calculated components is v (1≤v≤p), then the number of indirectly iteratively calculated components is w=p−v (0≤w<p). For any algorithm, there will be at least one component being directly iteratively calculated. It is possible that all components are directly iteratively calculated (in this case v=p and w=0). However, directly iteratively calculated components must be calculated in every iteration no matter if an autocorrelation function is accessed or not in a specific iteration.

For a given algorithm, if a component is directly iteratively calculated, then the component must be calculated in every iteration (i.e., whenever an existing data element is removed from and a data element is added to the computation window). However, if a component is indirectly iteratively calculated, then the component may be calculated as needed using one or more components other than the component itself, i.e., only when an autocorrelation function needs to be calculated and accessed. Thus, when an autocorrelation function is not accessed in a specific iteration, only a small number of components need to be iteratively calculated. It should be understood that an indirectly iteratively calculated component may also be used in the calculation of a directly iteratively calculated component. In that case, the indirectly iteratively calculated component should also be calculated in every iteration.

As used herein, a non-lag-related component is a component that does not have any relationship with lag, i.e., any lag change will not affect the component's calculation or value. For example, a sum or a mean is a non-lag-related component.

As used herein, a lag-related component is a component that contains lag in its definition, and thus when lag changes the component's value changes. For example, referring to FIG. 4B,

$\overset{n}{\sum\limits_{1 + l}}{\left( {x_{i} - {\overset{\_}{x}}_{k}} \right)\left( {x_{i - l} - {\overset{\_}{x}}_{k}} \right)}$ is a lag-related component.

A computing system includes an input buffer for storing Big Data or streamed data elements. A computation window size indicates a specified number of Big Data or streamed data elements for filling computation windows for the buffer. A lag upper limit maxl indicates the range of lags used for calculating an autocorrelation function.

The computing system accesses Big Data or streamed data elements for a computation window from the input buffer. For streamed data processing, removing a data or adding a data generally happens at either end of the buffer. The computation window may move to either right or left side direction. For example, when processing streamed data in real-time, the computation window moves to the right. In this case, a new data is always added to the right side of the computation window and an existing data is always removed from the left side of the computation window. When recalculating or reviewing autocorrelation functions on previous streamed data, the computation window may move to the left. In this case, an earlier data is added to the left side of the computation window and a recent data is removed from the right side of the computation window. Both cases may be handled in the same way but just the equations for iterative autocorrelation function calculation are different. By way of example, and not limitation, embodiments of the invention are described and explained using the first case (computation window moving to the right) as an example in the following descriptions.

The streamed data elements include an earlier (and possibly initial) streamed data element and one or more additional streamed data elements. The earlier streamed data element was accessed or received prior to the one or more additional streamed data elements. The lag l is initialized with a value of 1 or the lag upper limit maxl. The computing system calculates one or more (p (p≥1)) components of an autocorrelation at a given lag less than the lag upper limit for the computation window from the earlier streamed element and one or more additional streamed elements. The computing system stores the one or more (p (p≥1)) components at a given lag. The computing system updates the lag and then repeats the above calculation until one or more (p (p≥1)) components of an autocorrelation at all lags between 1 and the lag upper limit maxl are calculated and stored.

The computing system accesses or receives a new streamed data element subsequent to accessing or receiving the one or more additional streamed data elements. The computing system stores the new streamed data element in the input buffer. The computing system adjusts the computation window by: removing the earlier streamed data element from the computation window and adding the new streamed data element to the computation window. The computing system resets the lag to 1 or the lag upper limit whenever a new streamed data element is accessed or received.

The computing system directly iteratively calculates one or more v (1≤v≤p) components of an autocorrelation at different lags within a specified range respectively for the adjusted computation window and stores the calculated v components (e.g., into an array in memory or a file on disks). The computing system directly iteratively calculates v components of an autocorrelation at different lags for a given computation window through a loop: setting an initial value for a lag l, directly iteratively calculating v components of the autocorrelation at the lag, storing the calculated v components, adjusting the lag with a new value within the specified range, directly iteratively calculating v components at the lag, storing the calculated v components, adjusting the lag again, directly iteratively calculating v components for the lag again, storing the calculated v components again, . . . , repeating this process until v components at all different lag values within the specified range have been directly iteratively calculated and stored. Directly iteratively calculating v (1≤v≤p) components at a given lag l includes: accessing the data element removed from the computation window, l data elements next to the removed data element in the computation window, the new data element added to the computation window and l data elements next to the new data element in the computation window from the input buffer and accessing the v components at the given lag l calculated for the previous computation window; mathematically removing any contribution of the data element removed from the computation window from each of the v components at the given lag l; mathematically adding a contribution of the new data element to each of the v components at the given lag l.

The computing system indirectly iteratively calculates w=p−v components of an autocorrelation function at different lags within a specified range for the adjusted computation window as needed. The computing system indirectly iteratively calculates w components of an autocorrelation function at different lags for a given computation window through a loop: setting an initial value for a lag l, iteratively calculating w components of the autocorrelation at the lag, adjusting the lag with a new value within the specified range, calculating w components at the lag, adjusting the lag again, calculating w components at the lag again, . . . , repeating this process until w components at all different lag values within the specified range have been calculated. Indirectly iteratively calculating w components at a given lag l includes indirectly iteratively calculating each of the w components at the given lag l one by one. Indirectly iteratively calculating a component at a given lag l includes: accessing one or more components at the given lag l and calculating the component at the given lag by using the one or more components at the given lag other than the component itself (Depending on a specific algorithm used, calculating each of the w components may also need access and use the new data element added to the computation window). The one or more components at the given lag may have been initialized, directly iteratively calculated or indirectly iteratively calculated.

The computing system initializes a lag l, and generates an autocorrelation at the given lag for a given computation window as needed by using one or more iteratively calculated components of an autocorrelation at the given lag for the given computation window. The computing system adjusts the lag to a new value within a specified range (from 1 to maxl), then generates an autocorrelation at the given lag for a given computation window as needed by using one or more iteratively calculated components of an autocorrelation at the given lag for the given computation window. The computing system repeats this process until autocorrelation function at all lags within a specified range having been generated.

The computing system keeps accessing or receiving a new data element, storing the data element into a data buffer, adjusting the computation window, directly iteratively calculating v (1≤v≤p) components at all lags within a specified range and storing the v components, indirectly iteratively calculating w=p−v components at all lags within a specified range as needed and generating an autocorrelation function at all lags within a specified range as needed, and the computing system may repeat this process for as many times as needed.

Embodiments of the present invention may comprise or utilize a special purpose or general-purpose computing device including computing device hardware, such as, for example, one or more processors and system memory, as discussed in greater detail below. Embodiments within the scope of the present invention also include physical and other computing-device-readable media for carrying or storing computing-device-executable instructions and/or data structures. Such computing-device-readable media may be any available media that may be accessed by a general purpose or special purpose computing device. Computing-device-readable media that store computing-device-executable instructions are computing device storage media (devices). Computing-device-readable media that carry computing-device-executable instructions are transmission media. Thus, by way of example, and not limitation, embodiments of the invention may comprise at least two distinctly different kinds of computing-device-readable media: computing device storage media (devices) and transmission media.

Computing device storage media (devices) includes RAM, ROM, EEPROM, CD-ROM, solid state drives (“SSDs”) (e.g., based on RAM), Flash memory, phase-change memory (“PCM”), other types of memory, other optical disk storage, magnetic disk storage or other magnetic storage devices, or any other medium which may be used to store desired program code means in the form of computing-device-executable instructions or data structures and which may be accessed by a general purpose or special purpose computing device.

A “network” is defined as one or more data links that enable the transport of electronic data between computing devices and/or modules and/or other electronic devices. When information is transferred or provided over a network or another communications connection (either hardwired, wireless, or a combination of hardwired or wireless) to a computing device, the computing device properly views the connection as a transmission medium. Transmissions media may include a network and/or data links which may be used to carry desired program code means in the form of computing-device-executable instructions or data structures and which may be accessed by a general purpose or special purpose computing device. Combinations of the above should also be included within the scope of computing-device-readable media.

Further, upon reaching various computing device components, program code means in the form of computing-device-executable instructions or data structures may be transferred automatically from transmission media to computing device storage media (devices) (or vice versa). For example, computing-device-executable instructions or data structures received over a network or data link may be buffered in RAM within a network interface module (e.g., a “NIC”), and then eventually transferred to computing device RAM and/or to less volatile computing device storage media (devices) at a computing device. Thus, it should be understood that computing device storage media (devices) may be included in computing device components that also (or even primarily) utilize transmission media.

Computing-device-executable instructions comprise, for example, instructions and data which, when executed at a processor, cause a general purpose computing device or special purpose computing device to perform a certain function or group of functions. The computing device executable instructions may be, for example, binaries, intermediate format instructions such as assembly language, or even source code. Although the subject matter has been described in language specific to structural features and/or methodological acts, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to the described features or acts described above. Rather, the described features and acts are disclosed as example forms of implementing the claims.

Those skilled in the art will appreciate that embodiments of the present invention may be practiced in network computing environments with many types of computing device configurations, including, personal computers, desktop computers, laptop computers, message processors, hand-held devices, multi-processor systems, microprocessor-based or programmable consumer electronics, network PCs, minicomputers, mainframe computers, supercomputers, mobile telephones, PDAs, tablets, pagers, routers, switches, and the like. Embodiments of the present invention may also be practiced in distributed system environments where local and remote computing devices, which are linked (either by hardwired data links, wireless data links, or by a combination of hardwired and wireless data links) through a network, both perform tasks. In a distributed system environment, program modules may be located in both local and remote memory storage devices.

Embodiments of the invention may also be implemented in cloud computing environments. In this description and the following claims, “cloud computing” is defined as a model for enabling on-demand network access to a shared pool of configurable computing resources. For example, cloud computing may be employed in the marketplace to offer ubiquitous and convenient on-demand access to the shared pool of configurable computing resources. The shared pool of configurable computing resources may be rapidly provisioned via virtualization and released with low management effort or service provider interaction, and then scaled accordingly.

A cloud computing model may be composed of various characteristics such as, for example, on-demand self-service, broad network access, resource pooling, rapid elasticity, measured service, and so forth. A cloud computing model may also expose various service models, such as, for example, Software as a Service (“SaaS”), Platform as a Service (“PaaS”), and Infrastructure as a Service (“IaaS”). A cloud computing model may also be deployed using different deployment models such as private cloud, community cloud, public cloud, hybrid cloud, and so forth. In this description and in the claims, a “cloud computing environment” is an environment in which cloud computing is employed.

Within this description and the following claims, a “circular buffer” is a data structure that uses a single, fixed-size “buffer” as if it were connected end-to-end. A circular buffer may also be referred to as a cyclic buffer or a ring buffer. The “buffer” may be a commonly used circular buffer which is generally a space allocated in a local memory. The “buffer” may also be a “virtual circular buffer” which may reside in memory or other non-transitory computing-device-readable media, such as a hard disk or other media, and may include distributed memory or multiple distributed files on multiple distributed computing devices as if they were connected end-to-end to form a “circular buffer”.

FIG. 1 illustrates a high-level overview of an example computing system 100 that facilitates iteratively calculating autocorrelation for streamed data. Referring to FIG. 1, computing system 100 comprises multiple devices connected by different networks, such as local network, internet and wireless network, etc. The multiple devices include, for example, a data analysis engine 1007, a storage system 1011, live data stream 1006, and multiple distributed computing devices that may schedule data analysis tasks and/or query data analysis results, such as personal computer 1016, hand-held devices 1017 and desktop computer 1018, etc. Data analysis engine 1007 may comprise one or more processors, e.g., CPU 1009 and CPU 1010, one or more system memory, e.g., system memory 1008, and component calculation modules 191 and 131. Component calculation modules 191 and 131 will be illustrated in more details in other figures. Storage system 1011 may comprise one or more storage media, e.g., storage medium 1012 and storage medium 1014, which may be used for hosting Big Data sets. Data sets on storage system 1011 may be accessed by data analysis engine 1007. In general, data stream 1006 may comprise streamed data from different data sources, for example, stock quotes, audio data, video data, geospatial data, web data, mobile communication data, online gaming data, banking transaction data, sensor data, closed-captioning data, etc. To depict a few, real-time data 1000 may comprise data collected from sensor 1001, stock 1002, web 1003 and bank 1004, etc. in real-time. Data analysis engine 1007 may receive data elements from data stream 1006. It should be understood that FIG. 100 is provided to introduce a selection of concepts in a much simplified form, for example, distributed devices 1016 and 1017 may need to go through a firewall to connect data analysis engine 1007, and data accessed or received from data stream 1006 and/or storage system 1011 by data analysis engine 1007 may be filtered by data filters, etc.

FIG. 1A illustrates an example computing system architecture 100A that facilitates iteratively calculating autocorrelation for streamed data with all components (v=p≥1) being directly iteratively calculated. FIG. 1A illustrates 1007 and 1006 shown in FIG. 1. Referring to FIG. 1A, computing system architecture 100A includes component calculation module 131 and autocorrelation calculation module 192. Component calculation module 131 may be connected to (or is part of) a network, such as, for example, a Local Area Network (“LAN”), a Wide Area Network (“WAN”), and even the Internet. Accordingly, component calculation module 131 as well as any other connected computing devices and their components, may send and receive message related data (e.g., Internet Protocol (“IP”) datagrams and other higher layer protocols that utilize IP datagrams, such as, User Datagram Protocol (“UDP”), Real-time Streaming Protocol (“RTSP”), Real-time Transport Protocol (“RTP”), Microsoft® Media Server (“MMS”), Transmission Control Protocol (“TCP”), Hypertext Transfer Protocol (“HTTP”), Simple Mail Transfer Protocol (“SMTP”), etc.) over the network. The output of component calculation module 131 may be used as the input of autocorrelation calculation module 192, and autocorrelation calculation module 192 may generate autocorrelation 193.

In general, data stream 190 may be a sequence of digitally encoded signals (e.g., packets of data or data packets) used to transmit or receive information that is in the process of being transmitted. Data stream 190 may stream data elements, such as, for example, stock quotes, audio data, video data, geospatial data, web data, mobile communication data, online gaming data, banking transaction data, sensor data, closed-captioning data, etc., to computing system architecture 100A. Data stream 190 may be a live stream or may stream stored data.

As streamed data elements are accessed or received, the streamed data elements may be placed in a location within circular buffer 121. For example, data element 101 may be placed in location 121A, data element 102 may be placed in location 121B, data element 103 may be placed in location 121C, data element 104 may be placed in location 121D, data element 105 may be placed in location 121E, data element 106 may be placed in location 121F, data element 107 may be placed in location 121G, data element 108 may be placed in location 121H, and data element 109 may be placed in location 121.

Subsequently, data element 110 may be accessed or received. Data element 110 may be placed in location 121A (overwriting data element 101).

As depicted, circular buffer 121 has nine locations, 121A-121I and a computation window of eight (i.e., n=8). Data elements within the computation window may rotate as new data elements are placed within circular buffer 121. For example, when data element 109 is placed in location 121I, computation window 122 transits to computation window 122A. When data element 110 is subsequently placed in location 121A, computation window 122A transits to computation window 122B.

As depicted in FIG. 1A, lag initialization module 171 sets an initial value of lag whenever a new data element is accessed or received. There is also storage space for storing directly iteratively calculated one or more (v (v=p≥1)) components at different lag values. For example, 172 may be a storage space used for storing iteratively calculated component Cd₁ at a range of different lag values. 173 may be a storage space used for storing iteratively calculated component Cd_(v) at a range of different lag values. Lag update module 175 may update the lag by enumerating the lag within a specified range.

In general, component calculation module 131 comprises one or more (v (v=p≥1)) component calculation modules for calculating (v (v=p≥1)) components of autocorrelation for a set of n data elements in a computation window. The number v is the number of components involved in a specific iterative autocorrelation algorithm at a given lag, which varies depending on which iterative algorithm is used. As depicted in FIG. 1A, component calculation module 131 comprises component Cd₁ calculation module 161 and component Cd_(v) calculation module 162, and there are v−2 other component calculation modules between them. Each component calculation module calculates a specific component at a given lag. The lag will be changed within a specified range, e.g., from 1 to a specified upper limit maxl. The number maxl is a specified number to specify the upper limit of lag the autocorrelation calculation will be calculated at. For example, if maxl=10, then the autocorrelation on the same input data at lag l=1, lag l=2, lag l=3, . . . , lag l=10 will be calculated respectively. The value of maxl may be set as an input to the computing device. Usually, the value of maxl is set to be smaller than ¼ of the computation window size n. At a given lag, v components are calculated, and then the components are stored in a storage space, e.g., component Cd₁ is stored in storage space 172 and component Cd_(v) is stored in storage space 173. The storage space (e.g., 172 and/or 173) may be one or more arrays in memory or one or more files on hard drives. Then, the lag will be updated by lag update module 175, e.g., by increasing or decreasing the lag by 1. Then, the v component calculation modules calculate v components with the new lag value for the same computation window again, and then the calculated v components will be stored in the storage space. This process may be repeated until v components at a range of lags have been calculated. Theoretically, at each given lag l, v components need to be calculated, so for lags ranging from 1 to maxl, a total of up to v*maxl component values need to be calculated and stored. However in fact, only those components whose calculation directly related to lag need to be recalculated for each value of different lags, and thus the number of components calculated by component calculation module 131 is indeed less than v*maxl. For example, a sum or a mean of the data elements in a computation window is a component to be used by all iterative autocorrelation algorithms, but its value is not related to a lag and thus is not changing with different lags for the same computation window, so it is not necessary to recalculate the sum or mean while the lag is changing. Thus there are no more than v*maxl component values will be calculated by component calculation module 131 for a given computation window. The actual number of component values calculated by component calculation module 131 varies depending on the specific iterative algorithm used. As depicted in FIG. 1A, component calculation module 131 comprises component Cd₁ calculation module 161 and component Cd_(v) calculation module 162. What between them may be component Cd₂ calculation module, component Cd₃ calculation module, . . . , and component Cd_(v−1) calculation module. Component Cd₁ calculation module 161 comprises initialization module 132 for initializing component Cd₁ at a given lag and iterative algorithm 133 for directly iteratively calculating component Cd₁ at a given lag. Component Cd_(v) calculation module 162 comprises initialization module 138 for initializing component Cd_(v) at a given lag and iterative algorithm 139 for directly iteratively calculating component Cd_(v) at a given lag. Initialization module 132 is configured to calculate component Cd₁ for a set of n data elements in a computation window at a given lag and initialization module 138 is configured to calculate component Cd_(v) for a set of n data elements in a computation window at a given lag. Component Cd₁ 141 and component Cd_(v) 145 receive a full set of n data elements (i.e., 8 data elements) from a computation window as input. Initialization module 132 calculates component Cd₁ and initialization module 138 calculates component Cd_(v) for from the full set of n data elements at a given lag respectively. Thus, each data element contributes to the calculated components ranging from component Cd₁ to component Cd_(v) at a given lag. Initialization module 132 may be used for an initial component Cd₁ calculation or when autocorrelation calculations are reset. Similarly, initialization module 138 may be used for an initial component Cd_(v) calculation or when autocorrelation calculations are reset.

Iterative algorithms are also configured to calculate no more than v*maxl component values for a set of n data elements in a computation window. Iterative algorithm 133 accesses or receives a prior component Cd₁ at a given lag and a newly added data element from a computation window as input. Iterative algorithm 133 directly iteratively calculates a new component Cd₁ at a given lag for a computation window from the prior component Cd₁ at the given lag for the prior computation window, the data element removed from the computation window and the data element newly added to the computation window. Contribution removal module 133A may remove any contribution of the removed data element from the component Cd₁ at a given lag for the prior computation window. Contribution addition module 133B may add a contribution of the newly added data element to the component Cd₁ at the given lag for the prior computation window. Removing any contribution of the removed data element along with adding a contribution of the added data element may be used for calculating component Cd₁ at the given lag for the computation window. Iterative algorithm 139 works in a similar way as iterative algorithm 133. Iterative algorithm 139 accesses or receives a component Cd_(v) at a given lag for the prior computation window and a newly added data element from a computation window as input. Iterative algorithm 139 calculates a new component Cd_(v) at the given lag for the adjusted computation window from the component Cd_(v) at the given lag for the prior computation window, the data element removed from the computation window and the data element newly added to the computation window. Contribution removal module 139A may remove any contribution of the removed data element from the prior component Cd_(v) at the given lag. Contribution addition module 139B may add a contribution of the newly added data element to the prior component Cd_(v) at the given lag. Removing any contribution of the removed data element along with adding a contribution of the newly added data element may be used for calculating component Cd_(v) at the given lag for the computation window.

Once p*maxl (p=v≥1) components of an autocorrelation function at all lags within a specified range are calculated and stored by component calculation module 131, the computing device starts another loop to calculate an autocorrelation function as needed. Referring to FIG. 1A, computing system architecture 100A also includes lag initialization module 191, autocorrelation calculation module 192, autocorrelation 193 and lag update module 194. Lag initialization module 191 sets an initial value of lag (e.g., lag l=1 or lag l=lag upper limit maxl). Lag update module 194 updates the lag value to enumerate the lag for a specified range (e.g., l=l+1 or l=l−1). For a given lag, autocorrelation calculation module 192 may calculate the autocorrelation 193 at the given lag using one or more iteratively calculated components at the given lag.

As depicted in FIG. 1A, there are two separate loops to enumerate the lag for a specified range. One loop is used for calculating p (p=v≥1) components at a range of lags, and the other is used for calculating autocorrelations at a range of lags by using one or more components at a range of lags. The advantage of such separated loops is that when it is not necessary to calculate autocorrelation for every data change, the system or program may perform the component calculation loop only, and only when an autocorrelation result is accessed, the loop for calculating autocorrelation with a range of lags will be performed. The disadvantage of such strategy is that it needs extra space to store calculated no more than p*maxl component values. It is completely doable to combine the two loops into one loop. For example, for a given computation window, at a given lag, computing device 100A iteratively calculates p components, then uses one or more iteratively calculated components to calculate an autocorrelation at the given lag, then updates the lag, iteratively calculates p components, uses one or more iteratively calculated components to calculate an autocorrelation at the new lag, and repeats this process until all autocorrelations at a range of lags have been calculated. In this case, 172 and 173 are not needed, but for every data change, autocorrelation will be calculated no matter the autocorrelation will be accessed or not.

FIG. 1B illustrates an example computing system architecture 100B that facilitates iteratively calculating an autocorrelation for streamed data with some (v (1≤v<p)) components being directly iteratively calculated and some (w (w=p−v)) components being indirectly iteratively calculated. In certain implementations, the difference between the computing system architectures 100B and 100A may be that architecture 100B includes a component calculation module 135. All parts except component calculation module 135 in 100B work in a similar way as those parts with same reference numbers in 100A. Instead of repeating what have already been explained in the description about 100A, only the different part is discussed here. Number v in 100B may not be the same number v as in 100A, because some directly iteratively calculated components in 100A are indirectly iteratively calculated in 100B. In 100A, v=p≥1, but in 100B, 1≤v<p. Referring to FIG. 1B, computing system architecture 100B includes component calculation module 135. The output of components calculation module 131 may be used as the input of component calculation module 135, and the output of calculation modules 131 and 135 may be used as the input of autocorrelation calculation module 192, and autocorrelation calculation module 192 may generate autocorrelation 193. Component calculation module 135 generally includes w=p−v component calculation modules for indirectly iteratively calculating w components. For example, Component calculation module 135 includes calculation module 163 for indirectly iteratively calculating component Ci₁ and calculation module 164 for indirectly iteratively calculating component Ci_(w), and there are w−2 component calculation modules in between. Indirectly iteratively calculating w components includes indirectly iteratively calculating each of the w components one by one. Indirectly iteratively calculating a component includes accessing and using one or more components other than the component itself. The one or more components may have been initialized, directly iteratively calculated or indirectly iteratively calculated.

FIG. 2 illustrates a flow chart of an example method 200 for iteratively calculating autocorrelation for streamed data. Method 200 will be described with respect to the components and data of computing system architectures 100A and 100B.

Method 200 includes initializing a lag upper limit maxl, setting an initial value for lag l and initializing a computation window size n (201). For example, user may specify a lag upper limit maxl and a computation window size n. Referring to computing system architectures 100A and 100B, lag initialization module 171 may initialize lag l with an initial value (e.g., 1 or lag upper limit maxl).

Method 200 includes at the given lag l, initializing or calculating v (1≤v≤p) components of an autocorrelation from the streamed data elements in a computation window with size n (202). For example, method 200 may calculate v components according to their definitions by accessing and using streamed data elements for a computation window of the input (circular) buffer 121, the streamed data elements including an earlier streamed data element and one or more additional streamed data elements, the earlier streamed data element accessed or received prior to the one or more additional streamed data elements. Component calculation module 131 may access data elements 101, 102, 103, 104, 105, 106, 107 and 108 for computation window 122 of buffer 121. Data element 101 may be the earlier (and potentially initially) streamed element and data elements 102, 103, 104, 105, 106, 107 and 108 may be the one or more additional elements. Data element 101 may be accessed or received prior to data elements 102, 103, 104, 105, 106, 107 and 108. Initialization module 132 may initialize component Cd₁ at the given lag (1 or maxl) using data elements 101-108, and initialization module 138 may initialize component Cd_(v) at the given lag (1 or maxl) using data elements 101-108. For example, at the given lag (1 or maxl), initialization module 132 may be used for calculating component Cd₁ 141 at the given lag (1 or maxl) from data element 101 and data elements 102, 103, 104, 105, 106, 107 and 108. As depicted, component Cd₁ 141 includes contribution 151, contribution 152, and other contributions 153. Contribution 151 is a contribution from data element 101 to component Cd₁ 141 at the given lag (1 or maxl). Contribution 152 is a contribution from data element 102 to component Cd₁ 141 at the given lag (1 or maxl). Other contributions 153 are contributions from data elements 103, 104, 105, 106, 107 and 108 to component Cd₁ 141 at the given lag (1 or maxl). Similarly, initialization module 138 may be used for calculating component Cd_(v) 145 at the given lag (1 or maxl) from data element 101 and data elements 102, 103, 104, 105, 106, 107 and 108. As depicted, component Cd_(v) 145 at the given lag (1 or maxl) includes contribution 181, contribution 182, and other contributions 183. Contribution 181 is a contribution from data element 101 to component Cd_(v) 145 at the given lag (1 or maxl). Contribution 182 is a contribution from data element 102 to component Cd_(v) 145 at the given lag (1 or maxl). Other contributions 183 are contributions from data elements 103, 104, 105, 106, 107 and 108 to component Cd_(v) 145 at the given lag (1 or maxl).

Method 200 includes storing the initialized v components into a storage space (210). For example, referring to 100A and 100B, after initialization module 132 initializing component Cd₁ using data elements 101-108, component calculation module 131 may store component Cd₁ into storage space 172, and similarly, after initialization module 138 initializing component Cd_(v) using data elements 101-108, component calculation module 131 may store component Cd_(v) into storage space 173.

Method 200 includes updating lag l (211). For example, lag update module 175 may update lag l with a new value (e.g., by increasing or decreasing its value by 1) within a specified range (from 1 to maxl).

Method 200 includes determining whether lag I is within the specified range (212). If yes, v components at the updated lag I will be initialized. If not, method 200 includes either accessing or receiving next data element or beginning another loop for indirectly iteratively calculating w=p−v components and then calculating an autocorrelation using one or more iteratively calculated components at all lags within a specified range.

Method 200 includes at the given lag l, initializing or calculating v (1≤v≤p) components of an autocorrelation from the streamed data elements in a computation window with size n (202). For example, initialization module 132 may initialize component Cd₁ at the given lag (2 or maxl−1) using data elements 101-108, and initialization module 138 may initialize component Cd_(v) at the given lag (2 or maxl−1) using data elements 101-108.

Method 200 includes storing the initialized v components into a storage space (210). For example, referring to 100A and 100B, after initialization module 132 initializing component Cd₁ at the updated lag (2 or maxl−4) using data elements 101-108, component calculation module 131 may store component Cd₁ at the updated lag into storage space 172, and similarly, after initialization module 138 initializing component Cd_(v) at the updated lag (2 or maxl-4) using data elements 101-108, component calculation module 131 may store component Cd_(v) at the updated lag into storage space 173.

Method 200 includes repeating the above process until v (1≤v≤p) components at all lags within a specified range (from 1 to maxl) are initialized and stored.

Method 200 includes another loop for indirectly iteratively calculating w=p−v components and then calculating an autocorrelation using one or more iteratively calculated components at all lags within a specified range. Indirectly iteratively calculating w=p−v components and then calculating an autocorrelation using one or more iteratively calculated components at all lags within a specified range includes indirectly iteratively calculating w=p−v components and then calculating an autocorrelation using one or more iteratively calculated components at each of all lags within a specified range one by one. Method 200 includes initializing lag (213) to initialize the lag (e.g., setting to 1 or maxl).

Method 200 includes indirectly iteratively calculating each of w=p−v components at the given lag one by one as needed by using one or more components other than the component itself (214) when v<p, i.e., not all components are directly iteratively calculated. The w components are calculated only when an autocorrelation function is accessed. For example, referring to FIG. 1B where some components are directly iteratively calculated and some are indirectly iteratively calculated, calculation module 163 may indirectly iteratively calculate Ci₁ by using one or more components other than Ci₁, and calculation module 164 may indirectly iteratively calculate one or more components other than Ci_(w). The one or more components may have been initialized, directly iteratively calculated, or indirectly iteratively calculated.

Method 200 includes calculating an autocorrelation at the given lag l on a needed basis. When an autocorrelation is accessed, the autocorrelation at the given lag will be calculated by using one or more iteratively calculated components (215); else only the v components will be iteratively calculated.

Method 200 includes updating lag l (216) and determining whether lag l is within a specified range (217). If yes, w components for the updated lag l will be indirectly iteratively calculated as needed (214) and an autocorrelation at the updated lag l will be calculated using one or more iteratively calculated components (215). 215, 216 and 217 may be repeated until autocorrelations at all lags within a specified range have been calculated with all components being directly iteratively calculated. For example, in architecture 100A, lag initialization 191 may set lag l=1 or l=maxl, and autocorrelation calculation module 192 may calculate autocorrelation 193 at the given lag l, and lag update module 194 may update the lag l by increasing or decreasing its value by one, then autocorrelation calculation module may calculate autocorrelation 193 at the updated lag l. This process may be repeated until all autocorrelation at lags for a specified range have been calculated. 214, 215, 216 and 217 may be repeated until autocorrelations at all lags within a specified range have been calculated with some components being indirectly iteratively calculated. For example, in architecture 100B, lag initialization 191 may set lag l=1 or l=maxl, and calculation module 163 may indirectly iteratively calculate Ci₁ by using one or more components other than Ci₁, and calculation module 164 may indirectly iteratively calculate one or more components other than Ci_(w), . . . , and autocorrelation calculation module 192 may calculate autocorrelation 193 at the given lag l, and lag update module 194 may update the lag l by increasing or decreasing its value by one, then autocorrelation calculation module may calculate autocorrelation 193 for the updated lag l. This process (135, 192, 193 and 194) may be repeated until autocorrelations at all lags for a specified range have been calculated.

Method 200 includes accessing or receiving a streamed data element; storing the streamed data element in the input buffer; setting an initial value for lag l (203). For example, referring to 100A and 100B, a data element 109 may be accessed or received subsequent to accessing or receiving data elements 101-108. The data element 109 may be stored in location 121I of circular buffer 121. Lag initialization module 171 may set lag l with an initial value (e.g., 1 or maxl) when data element 109 is accessed or received.

Method 200 includes adjusting the computation window, including: removing an existing data element from the computation window and adding the accessed or received data element to the computation window (204). For example, computation window 122 may be transitioned to computation window 122A. Adjusting the computation window includes removing an existing (e.g., the least recent) data element from the computation window and adding the accessed or received data element to the computation window. For example, data element 101 is removed from computation window 122A and data element 109 is added to computation window 122A.

Method 200 includes at the given lag l directly iteratively calculating v (1≤v≤p) components of a next autocorrelation for the adjusted computation window (205) including: accessing the data element removed from the computation window, l data element(s) next to the removed data element in the computation window, the data element added to the computation window and l data element(s) next to the added data element in the computation window (206); accessing each of v (1≤v≤p) components (207); mathematically removing any contribution of the data element removed from the computation window from each of the v components (208); mathematically adding a contribution of the data element added to the computation window to each of the v components (209). Details are described below.

Directly iteratively calculating v components of a next autocorrelation at the given lag l for the adjusted computation window includes accessing the data element removed from the computation window, l data element(s) next to the removed data element in the computation window, the data element added to the computation window and l data element(s) next to the added data element in the computation window (206). For example, when at lag l=1, iterative algorithm 133 may access data element 101 which is removed from computation window 122A, data element 102 which is next to the removed data element 101, data element 109 which is added to computation window 122A and data element 108 which is next to the added data element 109. When at lag l=2, iterative algorithm 133 may access data element 101 which is removed from computation window 122A, data elements 102 and 103 which are the 2 data elements next to the removed data element 101, data element 109 which is added to computation window 122A and data elements 107 and 108 which are the 2 data elements next to the added data element 109 . . . . Similarly, when at lag l=1, iterative algorithm 139 may access data element 101 which is removed from computation window 122A, data element 102 which is next to the removed data element 101, data element 109 which is added to computation window 122A and data element 108 which is next to the added data element 109. When at lag l=2, iterative algorithm 139 may access data element 101 which is removed from computation window 122A, data elements 102 and 103 which are the 2 data elements next to the removed data element 101, data element 109 which is added to computation window 122A and data elements 107 and 108 which are the 2 data elements next to the added data element 109 . . . .

Directly iteratively calculating v components of a next autocorrelation at the given lag l for the adjusted computation window includes accessing v (1≤v≤p) components of the autocorrelation at the given lag l in the previous computation window (207). For example, when at lag l=1, iterative algorithm 133 may access component Cd₁ 141 at lag l=1, and when at lag l=2, iterative algorithm 133 may access component Cd₁ 141 at lag l=2 . . . . Similarly, when at lag l=1, iterative algorithm 139 may access component Cd_(v) 145 at lag l=1, and when at lag l=2, iterative algorithm 139 may access component Cd_(v) 145 at lag l=2 . . . .

Directly iteratively calculating v components of a next autocorrelation at the given lag l for the adjusted computation window includes mathematically removing any contribution of the data element removed from the computation window from each of the v components (208). For example, directly iteratively calculating component Cd₁ 143 at lag l=1 may include contribution removal module 133A mathematically removing contribution 151 (i.e., the contribution from data element 101) from component Cd₁ 141 at lag l=1, and directly iteratively calculating component Cd₁ 143 at lag l=2 may include contribution removal module 133A mathematically removing contribution 151 (i.e., the contribution from data element 101) from component Cd₁ 141 at lag l=2 . . . . Similarly, directly iteratively calculating component Cd_(v) 147 at lag l=1 may include contribution removal module 139A mathematically removing contribution 181 (i.e., the contribution from data element 101) from component Cd_(v) 145 at lag l=1, and directly iteratively calculating component Cd_(v) 147 at lag l=2 may include contribution removal module 139A mathematically removing contribution 181 (i.e., the contribution from data element 101) from component Cd_(v) 145 at lag l=2 . . . .

Directly iteratively calculating v components of a next autocorrelation at the given lag l for the adjusted computation window includes mathematically adding a contribution of the new streamed data element to each of the v components (209). For example, directly iteratively calculating component Cd₁ 143 at lag l=1 may include contribution addition module 133B mathematically adding contribution 154 to component 141 at lag l=1, and directly iteratively calculating component Cd₁ 143 at lag l=2 may include contribution addition module 133B mathematically adding contribution 154 to component 141 at lag l=2 . . . . Similarly, directly iteratively calculating component Cd_(v) 147 at lag l=1 may include contribution addition module 139B mathematically adding contribution 184 to component Cd_(v) 145 at lag l=1, and directly iteratively calculating component Cd_(v) 147 at lag l=2 may include contribution addition module 139B mathematically adding contribution 184 to component Cd_(v) 145 at lag l=2 . . . . Contribution 154 and 184 are contributions from data element 109.

As depicted in FIGS. 1A and 1B, at the given lag l, component Cd₁ 143 includes contribution 152 (a contribution from data element 102), other contributions 153 (contributions from data elements 103-108), and contribution 154 (a contribution from data element 109). Similarly, component Cd_(v) 147 includes contribution 182 (a contribution from data element 102), other contributions 183 (contributions from data elements 103-108), and contribution 184 (a contribution from data element 109).

Method 200 includes store all those calculated v components at the updated lag l (210).

Method 200 includes updating the lag (211) and determining whether the lag is within a specified range (212). If yes, method 200 includes continuing to calculate v components for the updated lag (205). For example, after lag update module 175 updating lag l by increasing or decreasing the lag by 1, and if lag l is between 1 and maxl then for the same computation window, initialization module 132 in component Cd₁ calculation module 161 calculates component Cd₁ again and stores component Cd₁ at the new lag to storage space 172, and initialization module 138 in component Cd_(v) calculation module 162 calculates component Cd_(v) again and stores component Cd_(v) at the new lag to storage space 173. 205, 211, 213 and 214 may be repeated until v components at all lags within a specified range have been calculated and stored.

Method 200 includes indirectly iteratively calculating each of w=p−v components at the given lag l one by one as needed by using one or more components other than the component itself (214) when v<p, i.e., not all components are directly iteratively calculated. The w components are calculated only when an autocorrelation function is accessed. For example, referring to FIG. 1B where some components are directly iteratively calculated and some are indirectly iteratively calculated, calculation module 163 may indirectly iteratively calculate Ci₁ by using one or more components other than Ci₁, and calculation module 164 may indirectly iteratively calculate Ci_(w) by using one or more components other than Ci_(w). The one or more components may have been initialized, directly iteratively calculated, or indirectly iteratively calculated.

Method 200 calculates autocorrelation on a needed basis. When an autocorrelation is accessed, the autocorrelation will be calculated by using one or more iteratively calculated components; else only the v components will be directly iteratively calculated. When an autocorrelation is accessed, method 200 includes initializing the lag (e.g., setting lag l to 1 or maxl) (213), indirectly iteratively calculating w components for the given lag l as needed (214), calculating an autocorrelation at the updated lag using one or more iteratively calculated components (215), updating the lag with a new value (e.g., increasing or decreasing its value by 1), and determining whether all lags within a specified range have been enumerated . . . 215, 216 and 217 may be repeated until autocorrelations at all lags within a specified range have been calculated with all components being directly iteratively calculated. For example, in architecture 100A, lag initialization 191 may set lag l=1, and autocorrelation calculation module 192 may calculate autocorrelation 193 at the given lag, and lag update module 194 may update the lag by increasing its value by one, then autocorrelation calculation module may calculate autocorrelation 193 for the updated lag. This process may be repeated until all autocorrelation at lags for a specified range have been calculated. 214, 215, 216 and 217 may be repeated until autocorrelations at all lags within a specified range have been calculated with some components being indirectly iteratively calculated. For example, in architecture 100B, lag initialization 191 may set lag l=1, and calculation module 163 may indirectly iteratively calculate Ci₁ by using one or more components other than Ci₁, and calculation module 164 may indirectly iteratively calculate Ci_(w) by using one or more components other than Ci_(w), . . . , and autocorrelation calculation module 192 may calculate autocorrelation 193 at the given lag, and lag update module 194 may update the lag by increasing or decreasing its value by one, then autocorrelation calculation module may calculate autocorrelation 193 for the updated lag. This process (135, 192, 193 and 194) may be repeated until autocorrelations at all lags for a specified range have been calculated. Once autocorrelation at all lags for a specified range have been calculated, method 200 includes accessing or receiving next streamed data element.

203-209 may be repeated as newer streamed data elements are accessed or received. 210-217 may be repeated as needed. For example, subsequent to accessing or receiving data element 109 and calculating component Cd₁ 143 and component Cd_(v) 147 at all lags within a specified range, data element 110 may be accessed or received (203). Once a new data is accessed or received, method 200 includes adjusting the computation window by removing an existing data element from the computation window and adding the newly accessed or received data element to the computation window (204). For example, data element 110 may be placed in location 121A overwriting data element 101. Computation window 122A may be transitioned to computation window 122B by removing data element 102 and adding data element 110.

Method 200 includes at a given lag l, directly iteratively calculating v components of a next autocorrelation for the adjusted computation window by using the v components for the previous computation window (205), including accessing the data element removed from the computation window, l data element(s) next to the removed data element in the computation window, the new data element added to the computation window and l data elements next to the added data element in the computation window (206) and accessing the v components (207) and mathematically removing any contribution of the data element removed from the computation window from each of the v components (208) and mathematically adding a contribution of the data element added to the computation window to each of the v components (209). For example referring to 100A and 100B, at a given lag l, e.g. l=1, iterative algorithm 133 may be used for directly iteratively calculating component Cd₁ 144 at lag 1 (for computation window 122B) by using component Cd₁ 143 at lag 1 (for computation window 122A). Iterative algorithm 133 may access data element 102 which is removed from computation window 122B, data element 103 which is next to removed data element 102, data element 110 which is added to computation window 122B and data element 109 which is next to added data element 110. Iterative algorithm 133 may access component Cd₁ 143 at lag l=1. Directly iteratively calculating component Cd₁ 144 at lag l=1 may include contribution removal module 133A mathematically removing contribution 152 (i.e., the contribution from data element 102) from component Cd₁ 143 at lag l=1. Directly iteratively calculating component Cd₁ 144 at lag l=1 may include contribution addition module 133B mathematically adding contribution 155 to component Cd₁ 143 at lag l=1. Contribution 155 is a contribution from data element 110. Similarly, at a given lag l, e.g. l=1, iterative algorithm 139 may be used for directly iteratively calculating component Cd_(v) 148 at lag l=1 (for computation window 122B) by using component Cd_(v) 147 at lag l=1 (for computation window 122A). Iterative algorithm 139 may access data element 102 which is removed from computation window 122B, data element 103 which is next to removed data element 102, data element 110 which is added to computation window 122B and data element 109 which is next to added data element 110. Iterative algorithm 139 may access component Cd_(v) 147 at lag l=1. Directly iteratively calculating component Cd_(v) 148 at lag l=1 may include contribution removal module 139A mathematically removing contribution 182 (i.e., the contribution from data element 102) from component Cd_(v) 147 at lag l=1. Directly iteratively calculating component Cd_(v) 148 may include contribution addition module 139B mathematically adding contribution 185 to component Cd_(v) 147 at lag l=1. Contribution 185 is a contribution from data element 110.

Method 200 includes storing the directly iteratively calculated v components at the given lag l (210). For example, component Cd₁ 144 at the given lag l may be stored in storage space 172 and component Cd₁ 148 at the given lag I may be stored in storage space 173.

As depicted, at a given lag l, component Cd₁ 144 includes other contributions 153 (contributions for data elements 103-108), contribution 154 (a contribution from data element 109), and contribution 155 (a contribution from data element 110), and component Cd_(v) 148 includes other contributions 183 (contributions for data elements 103-108), contribution 184 (a contribution from data element 109), and contribution 185 (a contribution from data element 110).

Method 200 includes updating lag l and determining whether v components at all lags within a specified range have been calculated and stored. If not, method 200 includes continuing to directly iteratively calculate v components at the updated lag. 203, 204, 205, 210, 211 and 212 may be repeated until v components for all lags within a specified range have been directly iteratively calculated and stored. If yes, method 200 includes indirectly iteratively calculating w components and autocorrelations at all lags within a specified range as needed.

Once v components for all lags within a specified range have been calculated and stored, method 200 includes another loop for indirectly iteratively calculating w components and autocorrelations at all lags within a specified range as needed. The loop will be executed only when an autocorrelation function is accessed. If no autocorrelation function is accessed, method 200 includes continuing to access or receive next data element and starts calculation for next computation window (203). If an autocorrelation function is accessed, method 200 includes initializing lag l (e.g., setting lag l=1 or lag l=maxl) (213), indirectly iteratively calculating w components at the given lag (214), calculating autocorrelation at the given lag using one or more initialized or iteratively calculated components at the given lag (215), then method 200 includes updating the lag (e.g., increasing or decreasing its value by 1) (216) and determining whether autocorrelation for all lags within a specified range have been calculated (217). If yes, method 200 includes continuing to access or receive a new data element and starts calculation for next computation window (203). If no, method 200 includes updating lag l (e.g., increasing or decreasing its value by 1) (216), and continue to calculate w components at the given lag (214) and autocorrelation at the given lag using one or more components at the given lag (215) until autocorrelation for all lags within a specified range have been calculated (217). 214, 215, 216 and 217 may be repeated until autocorrelations for a given computation window at all lags within a specified range have been calculated.

When a next new streaming data element is accessed or received, component Cd₁ 144 may be used for directly iteratively calculating a next component Cd₁ and component Cd_(v) 148 may be used for directly iteratively calculating a next component Cd_(v).

FIG. 3A illustrates data elements that are removed from and added to computation window 300A for iteratively calculating an autocorrelation function on streamed data. Computation window 300A moves to the right side direction. Referring to FIG. 3A, an existing data element is always removed from the left end and a new data element is always added to the right end of computation window 300A.

FIG. 3B illustrates data elements that are accessed from computation window 300A for iteratively calculating an autocorrelation function on streamed data. For computation window 300A, the first n data elements are accessed for directly iteratively calculating one or more (v (1≤v≤p)) components at each of lags ranging from 1 to maxl for the first computation window and then indirectly iteratively calculating w=p−v components as needed and then calculating an autocorrelation function as needed. As time progresses, a least recent data element, e.g., (m+1)^(th) data element, is removed and a new data element, e.g., (m+1)^(th) data element, is added to computation window 300A. One or more (v (1≤v≤p)) components at each of lags ranging from 1 to maxl for the adjusted computation window are then directly iteratively calculated by using v components calculated for the first computation window. When lag l=1, 4 data elements are accessed which includes the data element removed, 1 data element next to the data element removed, the data element added and 1 data element next to the data element added. When lag l=2, 6 data elements are accessed which includes the data element removed, 2 data elements next to the data element removed, the data element added and 2 data elements next to the data element added . . . . And when lag l=maxl, 2*(l+1) data elements are accessed for directly iteratively calculating v components at lag l=maxl. The 2*(l+1) data elements includes the data element removed, l data elements next to the data element removed, the data element added and l data elements next to the data element added. Then, lag is initialized with a value (e.g., 1 or lag upper limit maxl), and then indirectly iteratively calculating w=p−v components at each of lags ranging from 1 to maxl as needed and then calculating an autocorrelation function using one or more iteratively calculated components at each of lags ranging from 1 to maxl as needed. Then, computation window 300A is adjusted again by removing a least recent data element and adding a new data element . . . . For a given iterative algorithm, v is a constant, so the number of operations for directly iteratively calculating v components is a constant, and the number of operations for indirectly iteratively calculating w=p−v components is also a constant. So for each given lag, the computation workload is reduced. An autocorrelation function at all lags ranging from 1 to maxl is calculated, so the overall computation workload is reduced. The larger the n, the more substantial the reduction in computation workload.

FIG. 3C illustrates data elements that are removed from and added to, one of the two computation windows, computation window 300B for iteratively calculating an autocorrelation function on streamed data. Computation window 300B moves to the left side direction. Referring to FIG. 3C, a recent data element is always removed from the right end and a least recent data element is always added to the left end of computation window 300B.

FIG. 3D illustrates data elements that are accessed from, one of the two computation windows, computation window 300B for iteratively calculating an autocorrelation function on streamed data. For computation window 300B, the first n data elements are accessed for directly iteratively calculating one or more (v (1≤v≤p)) components at each of lags ranging from 1 to maxl for the first computation window and then indirectly iteratively calculating w=p−v components and calculating an autocorrelation function as needed. As time progresses, a most recent data element, e.g., (m+n)^(th) data element, is removed and a least recent data element, e.g., m^(th) data element, is added to computation window 300B. One or more (v (1≤v≤p)) components at each of lags ranging from 1 to maxl for the adjusted computation window are then directly iteratively calculated by using v components calculated for the first computation window. When lag l=1, 4 data elements are accessed which includes the data element removed, 1 data element next to the data element removed, the data element added and 1 data element next to the data element added. When lag l=2, 6 data elements are accessed which includes the data element removed, 2 data elements next to the data element removed, the data element added and 2 data elements next to the data element added . . . . And when lag l=maxl, 2*(l+1) data elements are accessed for directly iteratively calculating v components at lag l=maxl. The 2*(l+1) data elements includes the data element removed, l data elements next to the data element removed, the data element added and l data elements next to the data element added. Then, lag is initialized with a value (e.g., 1 or lag upper limit maxl), and then indirectly iteratively calculating w=p−v components at each of lags ranging from 1 to maxl as needed and then calculating an autocorrelation function using one or more iteratively calculated components at each of lags ranging from 1 to maxl as needed. Then, computation window 300B is adjusted again by removing a most recent data element and adding a least recent data element . . . . For a given iterative algorithm, v is a constant, so the number of operations for directly iteratively calculating v components is a constant, and the number of operations for indirectly iteratively calculating w=p−v components is also a constant. So for each given lag, the computation workload is reduced. An autocorrelation function at all lags ranging from 1 to maxl is calculated, so the overall computation workload is reduced. The larger the n, the more substantial the reduction in computation workload.

FIG. 4A illustrates the definition of autocorrelation. Suppose a computation window X=(x_(m+1), x_(m+2), . . . , x_(m+n)) is a window of streamed data which comprises the data elements to be involved in autocorrelation calculation. The computation window may move to either right or left direction. For example, when processing streamed data in real-time, the computation window moves to the right. In this case, a data is added to the right side of the computation window and a data is removed from the left side of the computation window. When recalculating autocorrelation on previous stream data, the computation window may move to the left. In this case, a data is added to the left side of the computation window and a data is removed from the right side of the computation window. The equations for calculating one or more (p (p≥1)) components for those two cases are different. To distinguish them, define the adjusted computation window as X^(I) for the former case and X^(II) for the latter case. Equation 401 is a traditional equation for calculating a sum S_(k) of all the data elements in X. Equation 402 is a traditional equation for calculating a mean x _(k) of all the data elements in X. Equation 403 is a traditional equation for calculating an autocorrelation ρ_((k,l)) with a lag l of all the data elements in a computation window of size n. Equation 404 is a traditional equation for calculating a sum S^(I) _(k+1) of all the data elements in the adjusted computation window X^(I). Equation 405 is a traditional equation for calculating a mean x ^(I) _(k+1) of all the data elements in the adjusted computation window X^(I). Equation 406 is a traditional equation for calculating an autocorrelation ρ^(I) _((k+1,l)) of all the data elements in the adjusted computation window X^(I). As stated earlier, when the computation window moves to the left, the adjusted computation window is defined as X^(II). Equation 407 is a traditional equation for calculating a sum S^(II) _(k+1) of all the data elements in the adjusted computation window X^(II). Equation 408 is a traditional equation for calculating a mean x ^(II) _(k+1) of all the data elements in the adjusted computation window X^(II). Equation 409 is a traditional equation for calculating an autocorrelation ρ^(II) _(k+1,l)) of all the data elements in the adjusted computation window X^(II).

FIG. 4B illustrates some example components of an autocorrelation and basic iterative component calculation equations. A component of an autocorrelation is a quantity or expression appearing in the autocorrelation's definition equation or any transforms of the equation. The following are some example components of an autocorrelation.

$S_{k} = {\sum\limits_{1}^{n}x_{i}}$ ${\overset{\_}{x}}_{k} = {\frac{1}{n}{\sum\limits_{1}^{n}x_{i}}}$ ${SS}_{k} = {\sum\limits_{1}^{n}x_{i}^{2}}$ ${SX}_{k} = {\sum\limits_{1}^{n}\left( {x_{i} - {\overset{\_}{x}}_{k}} \right)^{2}}$ ${covX}_{({k,l})} = {\sum\limits_{1 + l}^{n}{\left( {x_{i} - {\overset{\_}{x}}_{k}} \right)\left( {x_{i - l} - {\overset{\_}{x}}_{k}} \right)\left( {l\mspace{14mu}{is}\mspace{14mu}{the}\mspace{14mu}{lag}} \right)}}$ An autocorrelation may be calculated based on one or more (p (p≥1)) components or combinations of them, so there are multiple algorithms supporting iterative autocorrelation function calculation. To illustrate how to use components to iteratively calculate autocorrelation, three different iterative autocorrelation function calculation algorithms are given as examples. A new iteration of calculation is started each time any component of an autocorrelation is recalculated due to a data change in the computation window which causes a computation window to change to a new computation window (e.g., 122→122A→122B). A sum or a mean is the basic component to be used for calculating an autocorrelation. The equations for iteratively calculating a sum or a mean are basic iterative component equations which will be used by all example iterative autocorrelation calculation algorithms, therefore they are presented in FIG. 4B instead of each example iterative autocorrelation calculation algorithm. As stated earlier, when the computation window moves to the right, the adjusted computation window is defined as X^(I). Equation 410 is an equation for directly iteratively calculating a sum S^(I) _(k+1) of all the data elements in the adjusted computation window X^(I) by mathematically removing any contribution of the removed data element from the previous sum and mathematically adding a contribution of the added data element to the previous sum. Equation 411 is an equation for directly iteratively calculating a mean x ^(I) _(k+1) of all the data elements in the adjusted computation window X^(I) by mathematically removing any contribution of the removed data element from the previous mean and mathematically adding a contribution of the added data element to the previous mean. As stated earlier, when the computation window moves to the left, the adjusted computation window is defined as X^(II). Equation 412 is an equation for iteratively calculating a sum S^(II) _(k+1) of all the data elements in the adjusted computation window X^(II). Equation 413 is an equation for iteratively calculating a mean x ^(II) _(k+1) of all the data elements in the adjusted computation window X^(II). Either a sum or a mean will be used in all three iterative autocorrelation function calculation algorithms described below.

FIG. 4C illustrates the first example iterative autocorrelation calculation algorithm (iterative algorithm 1). As depicted in FIG. 4C, when a computation window moves to the right, iterative algorithm 1 comprises iterative calculation of components S^(I) _(k+1) or x ^(I) _(k+1), SS^(I) _(k+1), SX^(I) _(k+1), and covX^(I) _((k+1,l)), and an autocorrelation ρ^(I) _((k+1,l)) may be calculated by using components SX^(I) _(k+1) and covX^(I) _((k+1,l)) once they are calculated. Equation 410 may be used for directly iteratively calculating component S^(I) _(k+1) if component S_(k) is available. Equation 411 may be used for directly iteratively calculating component x ^(I) _(k+1) if component x _(k) is available. Equation 414 is a traditional equation for calculating component SS_(k) in the computation window X. Equation 415 is a traditional equation for calculating component SS^(I) _(k+1) in the adjusted computation window X^(I). Equation 416 may be used for directly iteratively calculating component SS^(I) _(k+1) in the adjusted computation window X^(I) if component SS_(k) is available. Equation 417 is a traditional equation for calculating component SX_(k) in the computation window X. Equation 418 is a traditional equation for calculating component SX^(I) _(k+1) in the adjusted computation window X^(I). Equations 419 may be used for indirectly iteratively calculating component SX^(I) _(k+1) in the adjusted computation window X^(I) if components S^(I) _(k+1) or x ^(I) _(k+1) and SS^(I) _(k+1) are available. Equations 419 comprise multiple equations but only one of them is needed depending on if a sum or a mean or both are available. Equation 420 is a traditional equation for calculating component covX_((k,l)) in the computation window X. Equation 421 is a traditional equation for calculating component covX^(I) _((k+1,l)) in the adjusted computation window X^(I). Equations 422 may be used for directly iteratively calculating component covX^(I) _((k+1,l)) in the adjusted computation window X^(I) if components covX_((k,l)), SS^(I) _(k+1), S_(k) or x _(k) and S^(I) _(k+1) or x ^(I) _(k+1) are available. Equations 422 comprise multiple equations but only one of them is needed depending on if a sum or a mean or both are available. Equation 423 may be used for indirectly calculating the autocorrelation ρ^(I) _((k+1,l)) at a given lag l for the adjusted computation window X^(I) once components covX^(I) _((k+1,l)) and SX^(I) _(k+1) are calculated. Equations 422 and 423 may be repeatedly applied for calculating autocorrelation with different lags. As depicted in FIG. 4C Cont'd, when a computation window moves to the left, iterative algorithm 1 comprises iterative calculation of components S^(II) _(k+1) or x ^(II) _(k+1), SS^(II) _(k+1), SX^(II) _(k+1), and covX^(II) _((k+1,l)), and an autocorrelation ρ^(II) _((k+1,l)) may be directly calculated by using components SX^(II) _(k+1) and covX^(II) _((k+1,l)) once they are calculated. Equation 412 may be used for directly iteratively calculating component S^(II) _(k+1) if component S_(k) is available. Equation 413 may be used for directly iteratively calculating component x ^(II) _(k+1) if component x _(k) is available. Equation 424 is a traditional equation for calculating component SS_(k) in the computation window X. Equation 425 is a traditional equation for calculating component SS^(II) _(k+1) in the adjusted computation window X^(II). Equation 426 may be used for directly iteratively calculating component SS^(II) _(k+1) in the adjusted computation window X^(II) if component SS_(k) is available. Equation 427 is a traditional equation for calculating component SX_(k) in the computation window X. Equation 428 is a traditional equation for calculating component SX^(II) _(k+1) in the adjusted computation window X^(II). Equations 429 may be used for indirectly iteratively calculating component SX^(II) _(k+1) in the adjusted computation window X^(II) if components S^(II) _(k+1) and/or x ^(II) _(k+1) and SS^(II) _(k+1) are available. Equations 429 comprise multiple equations but only one of them is needed depending on if a sum or a mean or both are available. Equation 430 is a traditional equation for calculating component covX_((k,l)) in the computation window X. Equation 431 is a traditional equation for calculating component covX^(II) _((k+1,l)) in the adjusted computation window X^(II). Equations 432 may be used for directly iteratively calculating component covX^(II) _((k+1,l)) in the adjusted computation window X^(II) if components covX_((k,l)), SS^(II) _(k+1), S_(k) or x _(k) and S^(II) _(k+1) or x ^(II) _(k+1) are available. Equations 432 comprise multiple equations but only one of them is needed depending on if a sum or a mean or both are available. Equation 433 may be used for indirectly calculating the autocorrelation ρ^(II) _((k+1,l)) to at a given lag l for the adjusted computation window X^(II) once components covX^(II) _((k+1,l)) and SX^(II) _(k+1) are calculated. Equations 432 and 433 may be repeatedly applied for calculating autocorrelation with different lags.

FIG. 4D illustrates the second example iterative autocorrelation calculation algorithm (iterative algorithm 2). As depicted in FIG. 4D, when a computation window moves to the right, iterative algorithm 2 comprises iterative calculation of components S^(I) _(k+1) or x ^(I) _(k+1), SX^(I) _(k+1), and covX^(I) _((k+1,l)), and an autocorrelation may be calculated by using components SX^(I) _(k+1) and covX^(I) _((k+1,l)), once they are calculated. Equation 410 may be used for directly iteratively calculating component S^(I) _(k+1) if component S_(k) is available. Equation 411 may be used for directly iteratively calculating component x _(k+1) if component x _(k) is available. Equation 434 is a traditional equation for calculating component SX_(k) in the computation window X. Equation 435 is a traditional equation for calculating component SX^(I) _(k+1) in the adjusted computation window X^(I). Equations 436 may be used for directly iteratively calculating component SX^(I) _(k+1) in the adjusted computation window X^(I) if components SX_(k), S^(I) _(k+1) and/or x ^(I) _(k+1) are available. Equations 436 comprise multiple equations but only one of them is needed depending on if a sum or a mean or both are available. Equation 437 is a traditional equation for calculating component covX_((k,l)) in the computation window X. Equation 438 is a traditional equation for calculating component covX^(I) _((k+1,l)) in the adjusted computation window X^(I). Equations 439 may be used for directly iteratively calculating component covX^(I) _((k+1,l)) in the adjusted computation window X^(I) if components covX_((k,l)), S_(k) or x _(k) and S^(I) _(k+1) or x ^(I) _(k+1) are available. Equations 439 comprise multiple equations but only one of them is needed depending on if a sum or a mean or both are available. Equation 440 may be used for indirectly iteratively calculating the autocorrelation ρ^(I) _((k+1,l)) for the adjusted computation window X^(I) using components covX^(I) _((k+1,l)) and SX^(I) _(k+1) once they are calculated. As depicted in FIG. 4D Cont'd, when a computation window moves to the left, iterative algorithm 2 comprises iterative calculation of components S^(II) _(k+1) or x ^(II) _(k+1), SX^(II) _(k+1), and covX^(II) _((k+1,l)), and an autocorrelation ρ^(II) _((k+1,l)) may be calculated by using components SX^(II) _(k+1) and covX^(II) _((k+1,l)) once they are calculated. Equation 412 may be used for directly iteratively calculating component S^(II) _(k+1) if component S_(k) is available. Equation 413 may be used for directly iteratively calculating component x ^(II) _(k+1) if component x _(k) is available. Equation 441 is a traditional equation for calculating SX_(k) in the computation window X. Equation 442 is a traditional equation for calculating component SX^(II) _(k+1) in the adjusted computation window X^(II). Equations 443 may be used for directly iteratively calculating component SX^(II) _(k+1) in the adjusted computation window X^(II) if components SX_(k), S^(II) _(k+1) and/or x ^(II) _(k+1) are available. Equations 443 comprise multiple equations but only one of them is needed depending on if a sum or a mean or both are available. Equation 444 is a traditional equation for calculating component covX_((k,l)) in the computation window X. Equation 445 is a traditional equation for calculating component covX^(II) _((k+1,l)) in the adjusted computation window X^(II). Equations 446 may be used for directly iteratively calculating component covX^(II) _((k+1,l)) in the adjusted computation window X^(II) if components covX_((k,l)), S_(k) or x _(k) and S^(II) _(k+1) or x ^(II) _(k+1) are available. Equations 446 comprise multiple equations but only one of them is needed depending on if a sum or a mean or both are available. Equation 447 may be used for calculating the autocorrelation ρ^(II) _((k+1,l)) for the adjusted computation window X^(II) using components covX^(II) _((k+1,l)) and SX^(II) _(k+1) once they are calculated.

FIG. 4E illustrates the third example iterative autocorrelation calculation algorithm (iterative algorithm 3). As depicted in FIG. 4E, iterative algorithm 3 comprises iterative calculation of components S^(I) _(k+1) or x ^(I) _(k+1), SX^(I) _(k+1), and covX^(I) _((k+1,l)), and an autocorrelation may be calculated by using components SX^(I) _(k+1) and covX^(I) _((k+1,l)), once they are calculated. Equation 410 may be used for directly iteratively calculating component S^(I) _(k+1) if component S_(k) is available. Equation 411 may be used for directly iteratively calculating component x ^(I) _(k+1) if component x _(k) is available. Equation 448 is a traditional equation for calculating component SX_(k) in the computation window X. Equation 449 is a traditional equation for calculating component SX^(I) _(k+1) in the adjusted computation window X^(I). Equations 450 are equations that may be used for directly iteratively calculating component SX^(I) _(k+1) in the adjusted computation window X^(I) if components SX_(k), S^(I) _(k+1) and/or x ^(I) _(k+1) are available. Equations 450 comprise multiple equations but only one of them is needed depending on if a sum or a mean or both are available. Equation 451 is a traditional equation for calculating component covX_((k,l)) in the computation window X. Equation 452 is a traditional equation for calculating component covX^(I) _((k+1,l)) in the adjusted computation window X^(I). Equations 453 are equations that may be used for directly iteratively calculating component covX^(I) _((k+1,l)) in the adjusted computation window X^(I) if components covX_((k,l)), S_(k) or x _(k) and S^(I) _(k+1) or x ^(I) _(k+1) are available. Equations 453 comprise multiple equations but only one of them is needed depending on if a sum or a mean or both are available. Equation 454 is an equation that may be used for calculating the autocorrelation ρ^(I) _((k+1,l)) for the adjusted computation window X^(I) using components covX^(I) _((k+1,l)) and SX^(I) _(k+1) once they are calculated. As depicted in FIG. 4E Cont'd, when a computation window moves to the left, iterative algorithm 3 comprises iterative calculation of components S^(II) _(k+1) or x ^(II) _(k+1), SX^(II) _(k+1), and covX^(II) _((k+1,l)), and an autocorrelation may be calculated by using components SX^(II) _(k+1) and covX^(II) _((k+1,l)), once they are calculated. Equation 412 may be used for directly iteratively calculating component S^(II) _(k+1) if component S_(k) is available. Equation 413 may be used for directly iteratively calculating component x ^(II) _(k+1) if component x _(k) is available. Equation 455 is a traditional equation for calculating component SX_(k) in the computation window X. Equation 456 is a traditional equation for calculating component SX^(II) _(k+1) in the adjusted computation window X^(II). Equations 457 are equations that may be used for directly iteratively calculating component SX^(II) _(k+1) in the adjusted computation window X^(II) if components SX_(k), S_(k) and/or x _(k), and S^(II) _(k+1) and/or x ^(II) _(k+1) are available. Equations 457 comprise multiple equations but only one of them is needed depending on if a sum or a mean or both are available. Equation 458 is a traditional equation for calculating component covX_((k,l)) in the computation window X. Equation 459 is a traditional equation for calculating component covX^(II) _((k+1,l)) in the adjusted computation window X^(II). Equations 460 are equations that may be used for directly iteratively calculating component covX^(II) _((k+1,l)) in the adjusted computation window X^(II) if components covX_((k,l)), S_(k) or x _(k) and S^(II) _(k+1) or x ^(II) _(k+1) are available. Equations 460 comprise multiple equations but only one of them is needed depending on if a sum or a mean or both are available. Equation 461 is an equation that may be used for calculating the autocorrelation ρ^(II) _((k+1,l)) for the adjusted computation window X^(II) by using components covX^(II) _((k+1,l)) and SX^(II) _(k+1) once they are calculated.

To demonstrate iterative autocorrelation function calculation algorithms and their comparison against traditional algorithms, three examples are given below. Three computation windows of data elements are used. For traditional algorithms, the calculations for all three computation windows are exactly the same. For iterative algorithms, initialization of one or more components is performed for the first computation window, and iterative calculations are performed for the second and third computation windows.

FIG. 5A illustrates an example of calculating an autocorrelation function at two lags (lag=1 and lag=2, i.e., maxl=2) for Streamed Big Data or Data Stream 501 using traditional algorithms. The example assumes the computation window moves from left to right. Computation window size 502 (n) is 4. Computation window 503 includes the first four data elements in Streamed Big Data or Data Stream 501. There are a total of 3 divisions, 9 multiplications, 9 additions, 14 subtractions when calculating the autocorrelation on 4 data elements without any optimization.

The same equations may be used for calculating the autocorrelation function for computation window 504 as shown in FIG. 5A Cont'd 1 and the autocorrelation for computation window 505 as shown in FIG. 5A Cont'd 2 respectively. Each of these calculations also includes a total of 3 divisions, 9 multiplications, 9 additions, 14 subtractions when calculating the autocorrelation on 4 data elements without any optimization. Traditional algorithms for calculating autocorrelation on n data elements at lags from 1 to l typically take a total of 1+l divisions, (1+l)n−Σ₁ ^(l) i multiplications, (2+l)(n−1)−Σ₁ ^(l) i additions, and (1+2l)n−2Σ₁ ^(l) i subtractions without any optimization.

FIG. 5B illustrates an example of calculating an autocorrelation function at two lags (lag=1 and lag=2, i.e., maxl=2) using iterative algorithm 1. The example assumes the computation window moves from left to right and a mean instead of a sum is used in the example. The calculations for computation window 503 uses traditional equations to calculate the initial values of components x ₁, SS₁, SX₁, covX_((1,1)) and covX_((1,2)). The autocorrelation of computation window 503 is then calculated by using those components. Equation 402 is used for calculating component x ₁. Equation 414 is used for calculating component SS₁. Equation 417 is used for calculating component SX₁. Equation 420 is used for calculating component covX_((1,1)) and covX_((1,2)) respectively. Equation 423 is used for calculating component ρ_((1,1)) and ρ_((1,2)) respectively. The autocorrelation ρ_((1,1)) for computation window 503 at lag=1 is calculated by using covX_((1,1)) and SX₁, and the autocorrelation ρ_((1,2)) for computation window 503 at lag=2 is calculated by using covX_((1,2)) and SX₁. There is a total of 3 divisions, 11 multiplications, 9 additions and 11 subtractions when calculating the autocorrelation function at lag=1 and lag=2 for a computation window of size 4.

However, starting from computation window 504, the components of the autocorrelation function at lag=1 and lag=2 for computation window 504 may be iteratively calculated from the components of the autocorrelation for computation window 503. For example, equation 411 may be used for directly iteratively calculating the component x ₂ by using x ₁ previously calculated for computation window 503. Equation 416 may be used for directly iteratively calculating the component SS₂ by using SS₁ previously calculated for computation window 503. Equation 419 may be used for indirectly iteratively calculating the component SX₂ by using SS₂ and x ₂. Equation 422 may be used for directly iteratively calculating the component covX_((2,1)) (lag=1) by using x ₁ and covX_((1,1)) (lag=1) previously calculated for computation window 503 and x ₂. Equation 422 may also be used for directly iteratively calculating the component covX_((2,2)) (lag=2) by using x ₁ and covX_((1,2)) (lag=2) previously calculated for computation window 503 and x ₂. Equation 423 may be used for indirectly iteratively calculating the autocorrelation ρ_((2,1)) at lag=1 by using covX_((2,1)) and SX₂ and the autocorrelation ρ_((2,2)) at lag=2 by using covX_((2,2)) and SX₂. There is a total of 3 divisions, 16 multiplications, 16 additions and 11 subtractions when calculating the autocorrelation function at lag=1 and lag=2 for a computation window of size 4.

FIG. 5C illustrates an example of calculating autocorrelation function at a range of two lags (lag=1 and lag=2, i.e., maxl=2) using iterative algorithm 2. The example assumes the computation window moves from left to right and a mean instead of a sum is used in the example. The calculations of calculating an autocorrelation function for computation window 503 uses traditional equations to calculate the initial values of components x ₁, SX₁, covX_((1,1)) and covX_((1,2)). For example, equation 402 may be used for calculating x ₁. Equation 434 may be used for calculating SX₁. Equation 437 may be used for calculating covX_((1,1)) and covX_((1,2)). The autocorrelation of computation window 503 ρ_((1,1)) (lag=1) and ρ_((1,2)) (lag=2) is then calculated by using those components through equation 440 respectively. There is a total of 3 divisions, 9 multiplications, 9 additions and 14 subtractions when calculating the autocorrelation function at lag=1 and lag=2 for a computation window of size 4.

FIG. 5C illustrates an example of calculating autocorrelation function using iterative algorithm 2. The example assumes the computation window moves from left to right and a mean instead of a sum is used in the example. The calculations of calculating an autocorrelation function for computation window 503 uses traditional equations to calculate the initial values of components x ₁, SX₁, covX_((1,1)) and covX_((1,2)). For example, equation 402 may be used for calculating x ₁. Equation 434 may be used for calculating SX₁. Equation 437 may be used for calculating covX_((1,1)) and covX_((1,2)). The autocorrelation of computation window 503 ρ_((1,1)) (lag=1) and ρ_((1,2)) (lag=2) is then calculated by using those components through equation 440 respectively. There is a total of 3 divisions, 9 multiplications, 9 additions and 14 subtractions when calculating the autocorrelation function at lag=1 and lag=2 on a computation window of size 4.

However, starting from computation window 504, the components of the autocorrelation function at lag=1 and lag=2 for computation window 504 may be iteratively calculated from the components of the autocorrelation for computation window 503. For example, equation 411 may be used for directly iteratively calculating the component x ₂ by using x ₁ previously calculated for computation window 503. Equation 436 may be used for directly iteratively calculating the component SX₂ by using SX₁ and x ₂. Equation 439 may be used for directly iteratively calculating the component covX_((2,1)) (lag=1) by using x ₁, x ₂ and covX_((1,1)). Equation 439 may also be used for directly iteratively calculating the component covX_((2,2)) (lag=2) by using x ₁, x ₂ and covX_((1,2)). Equation 440 may then be used for indirectly iteratively calculating the autocorrelations ρ_((2,1)) (lag=1) by using covX_((2,1)) and SX₂ and ρ_((2,2)) (lag=2) by using covX_((2,2)) and SX₂. There is a total of 3 divisions, 13 multiplications, 18 additions and 11 subtractions when calculating the autocorrelation function at lag l=1 and lag l=2 on a computation window of size 4.

The same equations may also be used for iteratively calculating the components of autocorrelation for computation window 505 from the components of autocorrelation for computation window 504. There is a total of 3 divisions, 13 multiplications, 18 additions and 11 subtractions when iteratively calculating the autocorrelation function. As such, since the number of operations performed by the iterative autocorrelation function calculation algorithm is fixed and not changing with the computation window size, starting from computation window 504, the number of operations used when iteratively calculating the autocorrelation function is (potentially substantially) less than when using traditional equations for computation windows with a large size.

FIG. 5D illustrates an example of calculating an autocorrelation function at two lags (lag=1 and lag=2, i.e., maxl=2) using iterative algorithm 3. The example assumes the computation window moves from left to right and a mean instead of a sum is used in the example. The calculations for computation window 503 uses traditional equations to calculate the initial values of components x ₁, SX₁, covX_((1,1)) and covX_((1,2)). For example, equation 402 may be used for calculating x ₁. Equation 448 may be used for calculating SX₁. Equation 451 may be used for calculating covX_((1,1)) and covX_((1,2)). Equation 454 may then be used for calculating the autocorrelation function of computation window 503 ρ_((1,1)) (lag=1) by using covX_((1,1)) and SX₁ and ρ_((1,2)) (lag=2) by using covX_((1,2)) and SX₁. There is a total of 3 divisions, 9 multiplications, 9 additions and 14 subtractions when calculating the autocorrelation function at lag=1 and lag=2 for a computation window of size 4.

However, for window 504, the components of the autocorrelation function at lag=1 and lag=2 for computation window 504 may be iteratively calculated from the components of the autocorrelation function for computation window 503. For example, equation 411 may be used for directly iteratively calculating the component x ₂ by using x ₁ previously calculated for computation window 503. Equation 450 may be used for directly iteratively calculating the component SX₂ by using SX₁, x ₁ and x ₂. Equation 453 may be used for directly iteratively calculating the component covX_((2,1)) by using x ₁, x ₂, and covX_((1,1)). Equation 453 may also be used for directly iteratively calculating the component covX_((2,2)) by using x ₁, x ₂, and covX_((1,2)). Equation 454 may then be used for indirectly iteratively calculating the autocorrelation function ρ_((2,1)) (lag=1) by using covX_((2,1)) and SX₂ and ρ_((2,2)) (lag=2) by using covX_((2,2)) and SX₂ respectively. There is a total of 3 divisions, 13 multiplications, 15 additions and 13 subtractions when calculating the autocorrelation function.

The same equations may also be used for iteratively calculating the components of autocorrelation function for computation window 505 from the components of autocorrelation function for computation window 504. There is also a total of 3 divisions, 13 multiplications, 15 additions and 13 subtractions when iteratively calculating the autocorrelation function. As such, since the number of operations performed by the iterative autocorrelation function calculation algorithm is fixed and not changing with the computation window size, starting from since the number of operations performed by the iterative autocorrelation function calculation algorithm is fixed and not changing with the computation window size, starting from computation window 504, the number of operations used when iteratively calculating the autocorrelation function is (potentially substantially) less than when using traditional equations for computation windows with a large size.

In the three examples above, a mean is used for the iterative autocorrelation function calculation. If a sum instead of a mean is used, autocorrelation may also be iteratively calculated though the numbers of operations are different. Also, the computation window moves from left to right in the three examples above. It works in a similar way when the computation window moves from right to left but just use a different set of equations.

FIG. 6 illustrates computational loads for traditional autocorrelation function algorithm and iterative autocorrelation function algorithms when n=4, maxl=2. As depicted, the computation loads are roughly at same level for traditional autocorrelation function algorithms and iterative autocorrelation function algorithms for computation windows of size 4.

FIG. 7 illustrates computational loads for traditional autocorrelation function algorithm and iterative autocorrelation function algorithms when n=1,000,000, maxl=2 for any computation window other than the first computation window. As depicted, there are substantially fewer multiplication operations, fewer addition operations, and fewer subtraction operations using any one of the iterative algorithms.

The present invention may be embodied in other specific forms without departing from its spirit or essential characteristics. The described embodiments are to be considered in all respects only as illustrative and not restrictive. The scope of the invention is, therefore, indicated by the appended claims rather than by the foregoing description. All changes which come within the meaning and range of equivalency of the claims are to be embraced within their scope. 

What is claimed:
 1. A computing-system-implemented method for generating an autocorrelation function at a specified range of lags for an adjusted computation window on a computing-device-based computing system which comprises one or more computing devices and one or more storage media, each computing device comprising one or more processors, the method comprising: initializing, by the computing-device-based computing system, multiple components of an autocorrelation function at a specified range of lags for a pre-adjusted computation window with a specified size n (n≥6) of a data stream, wherein the pre-adjusted computation window contains n data elements received from the data stream and stored in a buffer on at least one of the one or more storage media; receiving, by the computing-device-based computing system, a data element to be added to the pre-adjusted computation window; storing, by the computing-device-based computing system, the received data element in the buffer; adjusting, by the computing-device-based computing system, the pre-adjusted computation window by: removing a least recently received data element from the pre-adjusted computation window; and adding the received data element to the pre-adjusted computation window; directly iteratively deriving, by the computing-device-based computing system, multiple components of an autocorrelation function at the specified range of lags for the adjusted computation window based at least in part on the multiple components of the autocorrelation function at the specified range of lags initialized or derived for the pre-adjusted computation window, wherein the directly iteratively deriving includes: accessing each of the multiple components of the autocorrelation function at the specified range of lags for the pre-adjusted computation window without accessing all data elements in the adjusted computation window thereby saving computing resources and reducing the configured computing system's power consumption; and removing any contribution of the removed data element from each of the accessed components mathematically and adding any contribution of the added data element to each of the accessed components mathematically wherein not all data elements in the adjusted computation window are used in the computation to reduce number of operations performed by the configured computing system thereby increasing calculation efficiency; and generating, by the computing-device-based computing system, an autocorrelation function at the specified range of lags based on two or more of the iteratively derived components.
 2. The computing-system-implemented method of claim 1, wherein storing the received data element in the buffer comprises storing the data element in a circular buffer.
 3. The computing-system-implemented method of claim 1, wherein the receiving a data element to be added further comprises receiving a plurality of z (z>1) data elements to be added to the pre-adjusted computation window, and wherein the method further comprises performing, for each of the respective z data elements to be added, storing the received data element in the buffer, adjusting the pre-adjusted computation window, directly iteratively deriving the multiple components, and generating an autocorrelation function at the specified range of lags for the adjusted computation window for each of multiple data elements to be added.
 4. The computing-system-implemented method of claim 3, wherein the directly iteratively deriving the multiple components comprises performing a loop, the loop comprising for each given lag l within the specified range of lags: accessing, by the computing-device-based computing system, l data elements from each side of the pre-adjusted computation window without counting the added data element and the removed data element; accessing, by the computing-device-based computing system, one or more components of an autocorrelation at lag l for the pre-adjusted computation window; and deriving one or more components of an autocorrelation at lag l for the adjusted computation window by removing any contribution of the removed data element from each of the one or more accessed components mathematically and adding any contribution of the added data element to each of the one or more accessed components mathematically, by the computing-device-based computing system, based at least in part on the removed data element, the added data element, the accessed data elements, and the accessed components.
 5. The computing-system-implemented method of claim 4, wherein the loop further comprises for each given lag l within the specified range of lags storing the one or more calculated components into at least one of the one or more storage media.
 6. The computing-system-implemented method of claim 3, wherein the generating an autocorrelation function at the specified range of lags for the adjusted computation window comprises generating an autocorrelation function at the specified range of lags for the adjusted computation window only when the autocorrelation function is accessed.
 7. The computing-system-implemented method of claim 6, wherein the generating an autocorrelation function at the specified range of lags for the adjusted computation window comprises indirectly iteratively deriving, by the computing-device-based computing system, one or more components of an autocorrelation function at the specified range of lags for the adjusted computation window, wherein the indirectly iteratively deriving the one or more components includes individually calculating each respective one of the one or more components based on one or more components other than the respective one component.
 8. A computing system, the computing system comprising: one or more computing devices; each computing device comprising one or more processors; and one or more calculation modules that, when executed by at least one of the one or more computer devices, determine an autocorrelation function at a specified range of lags, wherein determination of the autocorrelation function includes to: a. initialize multiple components of an autocorrelation function at a specified range of lags for a pre-adjusted computation window with a specified size n (n≥6) of a data stream, wherein the pre-adjusted computation window contains n data elements received from the data stream and stored in a buffer on at least one of the one or more storage media; b. receive a data element to be added to the pre-adjusted computation window; c. store the received data element in the data buffer; d. adjust the pre-adjusted computation window, including to: remove a least recently received data element from the pre-adjusted computation window; and add the received data element to the pre-adjusted computation window; e. directly iteratively calculate multiple components of an autocorrelation function at a specified range of lags for the adjusted computation window based at least in part on the multiple components of the autocorrelation function at the specified range of lags initialized or calculated for the pre-adjusted computation window, including to: access each of the multiple components of the autocorrelation function at the specified range of lags for the pre-adjusted computation window without accessing all data elements in the adjusted computation window thereby saving computing resources and reducing the computing system's power consumption; and calculate each of the multiple components by mathematically removing any contribution of the removed data element from each of the accessed components and mathematically adding any contribution of the added data element to each of the accessed components wherein not all data elements in the adjusted computation window are used in the computation to reduce number of operations performed by the computing system thereby increasing calculation efficiency; and f. generate an autocorrelation function at the specified range of lags for the adjusted computation window based on two or more of iteratively calculated components.
 9. The computing system of claim 8, wherein the method includes, when executed by at least one of the one or more computing devices, performing b, c, d, e, and f multiple times.
 10. The computing system of claim 9, wherein the performing e comprises performing a loop, the loop comprising for each given lag l within the specified range of lags: accessing l data elements from each side of the pre-adjusted computation window without counting the added data element and the removed data element; accessing one or more components of an autocorrelation at lag l for the pre-adjusted computation window; and calculating one or more components of an autocorrelation at lag l for the adjusted computation window by removing any contribution of the removed data element from each of the accessed components mathematically and adding any contribution of the added data element to each of the accessed components mathematically based at least in part on the removed data element, the added data element, the accessed data elements, and the accessed components.
 11. The computing system of claim 10, wherein the loop further comprises storing the one or more calculated components into at least one of the one or more storage media.
 12. The computing system of claim 8, wherein the method includes, when executed by at least one of the one or more computing devices, performing b, c d, and e multiple times.
 13. The computing system of claim 9, wherein the performing e comprises generating an autocorrelation function at the specified range of lags for the adjusted computation window only when the autocorrelation function is accessed.
 14. The computing system of claim 13, wherein the generating an autocorrelation function further comprises indirectly iteratively calculating one or more components of the autocorrelation function, wherein the indirectly iteratively calculating one or more components includes individually calculating each respective one of the one or more components based on one or more components other than the respective one component.
 15. A computing system program product for use at a configured computing system which comprises one or more computing devices and one or more storage media, each computing device comprising one or more processors, the computing system program product comprising computing-device-executable instructions that have been stored on one or more non-transitory storage media that, when executed by at least one of the one or more computing devices in the configured computing system, cause the configured computing system to perform a method for generating an autocorrelation function at a specified range of lags for data elements in an adjusted computation window, the method including steps to: initialize, by the configured computing system, multiple components of an autocorrelation function at a specified range of lags for a pre-adjusted computation window with a specified size n (n≥6) of a data stream, wherein the pre-adjusted computation window contains n data elements received from the data stream and stored in a buffer on at least one of the one or more storage media; receive, by the configured computing system, a data element to be added to the pre-adjusted computation window; store, by the configured computing system, the received data element in the buffer; adjust, by the configured computing system, the pre-adjusted computation window, including to: remove a least recently received data element from the pre-adjusted computation window; and add the received data element to the pre-adjusted computation window; directly iteratively calculate, by the configured computing system, multiple components of an autocorrelation function at the specified range of lags for the adjusted computation window based at least in part on the multiple components of the autocorrelation function at the specified range of lags initialized or calculated for the pre-adjusted computation window, including to: access each of the multiple components of the autocorrelation function at the specified range of lags for the pre-adjusted computation window without accessing all data elements in the adjusted computation window thereby saving computing resources and reducing the configured computing system's power consumption; and remove any contribution of the removed data element from each of the accessed components mathematically and adding any contribution of the added data element to each of the accessed components mathematically wherein not all data elements in the adjusted computation window are used in the computation to reduce number of operations performed by the configured computing system thereby increasing calculation efficiency; and generate, by the configured computing system, an autocorrelation function at the specified range of lags based on two or more of the iteratively calculated components.
 16. The computing system program product of claim 15, wherein the computing-device-executable instructions that, when executed, further cause the configured computing system to receive a data element, to store the received data element in the buffer, to adjust the pre-adjusted computation window, to directly iteratively calculate the multiple components, and to generate an autocorrelation function at the specified range of lags for the adjusted computation window for each of multiple data elements to be received.
 17. The computing system program product of claim 16, wherein computing-device-executable instructions that, when executed, cause the configured computing system to directly iteratively calculate the multiple components comprise computing-device-executable instructions that, when executed, cause the configured computing system to perform a loop, the loop comprising for each given lag l within the specified range of lags: accessing l data elements from each side of the pre-adjusted computation window without counting the added data element and the removed data element; accessing one or more components of an autocorrelation at lag l for the pre-adjusted computation window; and calculating one or more components of an autocorrelation at lag l for the adjusted computation window by removing any contribution of the removed data element from each of the accessed components mathematically and adding any contribution of the added data element to each of the accessed components mathematically based at least in part on the removed data element, the added data element, the accessed data elements, and the accessed components.
 18. The computing system program product of claim 17, wherein the computing-device-executable instructions that, when executed, cause the configured computing system to perform a loop further comprise computing-device-executable instructions that, when executed, cause the configured computing system to store the one or more calculated components into at least one of the one or more storage media within the loop.
 19. The computing system program product of claim 15, wherein the computing-device-executable instructions that, when executed, further cause the configured computing system to receive a data element, to store the received data element in the buffer, to adjust the pre-adjusted computation window, and to directly iteratively calculate the one or more components for the adjusted computation window for each of multiple data elements to be received.
 20. The computing system program product of claim 16, wherein the computing-device-executable instructions that, when executed, cause the configured computing system to generate an autocorrelation function comprise computing-device-executable instructions that, when executed, further cause the configured computing system to indirectly iteratively calculate one or more components of the autocorrelation function, wherein the indirectly iteratively calculating the one or more components includes individually calculating each respective one of the one or more components based on one or more components other than the respective one component. 